package com.atguigu.gulimall.search.Thread;

import java.util.concurrent.*;

public class ThreadTest {

    public static ExecutorService service = Executors.newFixedThreadPool(10);

    /**
     * 创建线程池：ExecutorService
     *  1、Executors 直接提交
     *
     *  2、new ThreadPoolExecutor();
     *  7大参数
     *      *      int corePoolSize, 核心线程数[一直存在除非allowCoreThreadTimeOut]，创建好以后就准备好的线程数量，就等待接收异步任务执行
     *      *      int maximumPoolSize, 最大线程数量,控制资源
     *      *      long keepAliveTime, 存活时间，如果当前线程数大于核心线程数 等待keepAliveTime还没有任务就释放空闲线程
     *      *      TimeUnit unit, 指定存活时间的时间单位
     *      *      BlockingQueue<Runnable> workQueue, 阻塞队列 如果当前队列过多就放在队列里面，只有有空闲线程就会从队列取出来执行
     *      *      ThreadFactory threadFactory, 线程创建工厂
     *      *      RejectedExecutionHandler handler 队列满了 按照拒绝策略  拒绝任务执行
     *   执行顺序
     *      1、线程池创建，准备好core数量的核心线程，准备执行任务
     *        core 核心数满了，就将再进来的进程放进队列中，空闲的线程就会自己去队列中取任务执行
     *        阻塞队列满了，就直接开新线程执行，最大只能开max指定的数量
     *        max满了就使用拒绝策略RejectedExecutionHandler
     *        max都执行完成，在指定的时间keepAliveTime回收maximumPoolSize - corePoolSize线程
     *
     * @param args
     */
    public static void main(String[] args) {
//        System.out.println("mian start");
//        new Thread(new Runable1()).start();
//        System.out.println("end");
//          service.execute(new Runable1());
        ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5,
                200,
                10,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<>(10000),
                Executors.defaultThreadFactory(),
                new ThreadPoolExecutor.AbortPolicy()
        );

        //可使用Executors创建
//        Executors.newFixedThreadPool();

    }
}

class Runable1 implements Runnable{

    @Override
    public void run() {
        System.out.println("thread 。。。");
    }
}